package com.ruoyi.controller.tool;

//
//
//import org.opencv.core.Mat;
//
//import org.opencv.core.Size;
//import org.opencv.highgui.HighGui;
//import org.opencv.imgcodecs.Imgcodecs;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.core.io.FileUtil;
import com.freewayso.image.combiner.ImageCombiner;
import com.freewayso.image.combiner.enums.OutputFormat;
import org.bytedeco.opencv.global.opencv_imgcodecs;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.springframework.stereotype.Component;
//
//
//import javax.imageio.ImageIO;
//import java.awt.image.BufferedImage;
//import java.io.File;
//
//import java.io.IOException;


import org.bytedeco.opencv.opencv_core.*;
import org.bytedeco.opencv.opencv_optflow.*;
import org.bytedeco.opencv.opencv_video.*;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import static org.bytedeco.opencv.global.opencv_core.*;
import static org.bytedeco.opencv.global.opencv_imgcodecs.imread;
import static org.bytedeco.opencv.global.opencv_optflow.*;
import static org.bytedeco.opencv.global.opencv_video.*;
import org.bytedeco.opencv.opencv_core.Mat;



@Component
public class ImageTool {

    public boolean raw转jpg(String rawImagePath,String jpgImagePath){

        try {
            System.out.println("rawImagePath = " + rawImagePath);
            // 读取raw格式的图片


            File rawImageFile = new File(rawImagePath);
            BufferedImage rawImage = ImageIO.read(rawImageFile);

            System.out.println("rawImage = " + rawImage);
            // 将raw格式的图片转换为jpg格式
            File jpgImageFile = new File(jpgImagePath);
            ImageIO.write(rawImage, "jpg", jpgImageFile);

            System.out.println("成功将raw格式的图片转换为jpg格式！");
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }

        return true;
    }


    public boolean 图片放大(String file,String save) throws Exception {


//        Mat src = imread("E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H2.bmp");
//        HighGui gui = new HighGui();
//        gui.imshow("哈妮", src);
//        gui.waitKey(1000);

        String filePath = "E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H2.bmp";

        save = "E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H5.bmp";

//        String bg = "https://he4966.cn/template/default/index/images/new2.jpg";
//        ImageCombiner combiner = new ImageCombiner(bg, OutputFormat.JPG);
//        combiner.addImageElement(ImageIO.read(new File(filePath)),384,288);
//        combiner.save("E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H4.bmp");

        ImgUtil.scale(
                FileUtil.file(filePath),
                FileUtil.file(save),
                1.5f//缩放比例
        );
//        ImgUtil.scale(
//                FileUtil.file(filePath),
//                FileUtil.file(save),384,288,new Color(0,0,0)
//        );
//        File imageFile = new File(filePath);
//        BufferedImage originalImage = ImageIO.read(imageFile);
//
//        int originalWidth = originalImage.getWidth();
//        int originalHeight = originalImage.getHeight();
//        int newWidth = (int) (originalWidth * 1.3);
//        int newHeight = originalHeight;
//
//        BufferedImage newImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
//        newImage.getGraphics().drawImage(originalImage.getScaledInstance(newWidth, newHeight, BufferedImage.SCALE_SMOOTH), 0, 0, null);

//        return newImage;


//            // 读取本地图片文件
//            Mat src = imread("E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H2.raw.bmp");
//
//            // 检查源图像的尺寸是否为256x288
////            if (src.cols() != 256 || src.rows() != 288) {
////                System.out.println("原始图像的尺寸不是256x288");
////                return;
////            }
//
//            // 放大图像尺寸为384x288
//            Mat dst = new Mat();
//            Imgproc.resize(src, dst, new Size(384, 288));
//
//            // 保存放大后的图像文件
//            Imgcodecs.imwrite("E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H3.raw.bmp", dst);


//            Mat image = imread("E:/Code/JAVA/RuoYi-Vue/ruoyi-ray/src/main/resources/static/H2.raw.bmp");
//            Mat new_img = new Mat();
//            Imgproc.resize(image,new_img,new Size(384,288));
//        Imgcodecs.imwrite("E:\\Code\\JAVA\\RuoYi-Vue\\ruoyi-ray\\src\\main\\resources\\static\\H3.raw.bmp", new_img);


        return true;
    }

//
//
//
//    /**
//     * 图像缩放处理
//     * @author 小帅丶
//     *
//     */
//    public class ImageHelper {
//        /**
//         * 实现图像的等比缩放
//         * @param source
//         * @param targetW
//         * @param targetH
//         * @return
//         */
//        public static BufferedImage resize(BufferedImage source, int targetW,
//                                           int targetH) {
//            // targetW，targetH分别表示目标长和宽
//            int type = source.getType();
//            BufferedImage target = null;
//            double sx = (double) targetW / source.getWidth();
//            double sy = (double) targetH / source.getHeight();
//            // 这里想实现在targetW，targetH范围内实现等比缩放。如果不需要等比缩放
//            // 则将下面的if else语句注释即可
//            if (sx < sy) {
//                sx = sy;
//                targetW = (int) (sx * source.getWidth());
//            } else {
//                sy = sx;
//                targetH = (int) (sy * source.getHeight());
//            }
//            if (type == BufferedImage.TYPE_CUSTOM) { // handmade
//                ColorModel cm = source.getColorModel();
//                WritableRaster raster = cm.createCompatibleWritableRaster(targetW,
//                        targetH);
//                boolean alphaPremultiplied = cm.isAlphaPremultiplied();
//                target = new BufferedImage(cm, raster, alphaPremultiplied, null);
//            } else
//                target = new BufferedImage(targetW, targetH, type);
//            Graphics2D g = target.createGraphics();
//            // smoother than exlax:
//            g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
//                    RenderingHints.VALUE_INTERPOLATION_BICUBIC);
//            g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));
//            g.dispose();
//            return target;
//        }
//
//        /**
//         * 实现图像的等比缩放和缩放后的截取, 处理成功返回true, 否则返回false
//         * @param inFilePath 要截取文件的路径
//         * @param outFilePath 截取后输出的路径
//         * @param width 要截取宽度
//         * @param hight 要截取的高度
//         * @throws Exception
//         */
//        public static boolean compress(String inFilePath, String outFilePath,
//                                       int width, int hight) {
//            boolean ret = false;
//            File file = new File(inFilePath);
//            File saveFile = new File(outFilePath);
//            InputStream in = null;
//            try {
//                in = new FileInputStream(file);
//                ret = compress(in, saveFile, width, hight);
//            } catch (FileNotFoundException e) {
//                e.printStackTrace();
//                ret = false;
//            } finally{
//                if(null != in){
//                    try {
//                        in.close();
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }
//
//            return ret;
//        }
//
//        /**
//         * 实现图像的等比缩放和缩放后的截取, 处理成功返回true, 否则返回false
//         * @param in 要截取文件流
//         * @param outFilePath 截取后输出的路径
//         * @param width 要截取宽度
//         * @param hight 要截取的高度
//         * @throws Exception
//         */
//        public static boolean compress(InputStream in, File saveFile,
//                                       int width, int hight) {
////     boolean ret = false;
//            BufferedImage srcImage = null;
//            try {
//                srcImage = ImageIO.read(in);
//            } catch (IOException e) {
//                e.printStackTrace();
//                return false;
//            }
//
//            if (width > 0 || hight > 0) {
//                // 原图的大小
//                int sw = srcImage.getWidth();
//                int sh = srcImage.getHeight();
//                // 如果原图像的大小小于要缩放的图像大小，直接将要缩放的图像复制过去
//                if (sw > width && sh > hight) {
//                    srcImage = resize(srcImage, width, hight);
//                } else {
//                    String fileName = saveFile.getName();
//                    String formatName = fileName.substring(fileName
//                            .lastIndexOf('.') + 1);
//                    try {
//                        ImageIO.write(srcImage, formatName, saveFile);
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                        return false;
//                    }
//                    return true;
//                }
//            }
//            // 缩放后的图像的宽和高
//            int w = srcImage.getWidth();
//            int h = srcImage.getHeight();
//            // 如果缩放后的图像和要求的图像宽度一样，就对缩放的图像的高度进行截取
//            if (w == width) {
//                // 计算X轴坐标
//                int x = 0;
//                int y = h / 2 - hight / 2;
//                try {
//                    saveSubImage(srcImage, new Rectangle(x, y, width, hight), saveFile);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                    return false;
//                }
//            }
//            // 否则如果是缩放后的图像的高度和要求的图像高度一样，就对缩放后的图像的宽度进行截取
//            else if (h == hight) {
//                // 计算X轴坐标
//                int x = w / 2 - width / 2;
//                int y = 0;
//                try {
//                    saveSubImage(srcImage, new Rectangle(x, y, width, hight), saveFile);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                    return false;
//                }
//            }
//
//            return true;
//        }
//
//        /**
//         * 实现图像的等比缩放和缩放后的截取, 处理成功返回true, 否则返回false
//         * @param in 图片输入流
//         * @param saveFile 压缩后的图片输出流
//         * @param proportion 压缩比
//         * @throws Exception
//         */
//        public static boolean compress(InputStream in, File saveFile, int proportion) {
//            if(null == in
//                    ||null == saveFile
//                    ||proportion < 1){// 检查参数有效性
//                //LoggerUtil.error(ImageHelper.class, "--invalid parameter, do nothing!");
//                return false;
//            }
//
//            BufferedImage srcImage = null;
//            try {
//                srcImage = ImageIO.read(in);
//            } catch (IOException e) {
//                e.printStackTrace();
//                return false;
//            }
//            // 原图的大小
//            int width = srcImage.getWidth() / proportion;
//            int hight = srcImage.getHeight() / proportion;
//
//            srcImage = resize(srcImage, width, hight);
//
//            // 缩放后的图像的宽和高
//            int w = srcImage.getWidth();
//            int h = srcImage.getHeight();
//            // 如果缩放后的图像和要求的图像宽度一样，就对缩放的图像的高度进行截取
//            if (w == width) {
//                // 计算X轴坐标
//                int x = 0;
//                int y = h / 2 - hight / 2;
//                try {
//                    saveSubImage(srcImage, new Rectangle(x, y, width, hight), saveFile);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                    return false;
//                }
//            }
//            // 否则如果是缩放后的图像的高度和要求的图像高度一样，就对缩放后的图像的宽度进行截取
//            else if (h == hight) {
//                // 计算X轴坐标
//                int x = w / 2 - width / 2;
//                int y = 0;
//                try {
//                    saveSubImage(srcImage, new Rectangle(x, y, width, hight), saveFile);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                    return false;
//                }
//            }
//
//            return true;
//        }
//
//        /**
//         * 实现缩放后的截图
//         * @param image 缩放后的图像
//         * @param subImageBounds 要截取的子图的范围
//         * @param subImageFile 要保存的文件
//         * @throws IOException
//         */
//        private static void saveSubImage(BufferedImage image,
//                                         Rectangle subImageBounds, File subImageFile) throws IOException {
//            if (subImageBounds.x < 0 || subImageBounds.y < 0
//                    || subImageBounds.width - subImageBounds.x > image.getWidth()
//                    || subImageBounds.height - subImageBounds.y > image.getHeight()) {
//                //LoggerUtil.error(ImageHelper.class, "Bad subimage bounds");
//                return;
//            }
//            BufferedImage subImage = image.getSubimage(subImageBounds.x,subImageBounds.y, subImageBounds.width, subImageBounds.height);
//            String fileName = subImageFile.getName();
//            String formatName = fileName.substring(fileName.lastIndexOf('.') + 1);
//            ImageIO.write(subImage, formatName, subImageFile);
//        }
//
//
//        public static void main(String[] args) throws Exception {
//            /**
//             * saveSubImage 截图类的使用
//             * srcImage 为BufferedImage对象
//             * Rectangle    为需要截图的长方形坐标
//             * saveFile 需要保存的路径及名称
//             * **/
//            //需要截图的长方形坐标
//        /*Rectangle rect =new Rectangle();
//        rect.x=40;
//        rect.y=40;
//        rect.height=160;
//        rect.width=160;
//
//        InputStream in = null;
//        //需要保存的路径及名称
//        File saveFile = new File("d:\\ioc\\files\\aaa2.jpg");
//        //需要进行处理的图片的路径
//        in = new FileInputStream(new File("d:\\ioc\\files\\aaa.jpg"));
//        BufferedImage srcImage = null;
//        //将输入的数据转为BufferedImage对象
//        srcImage = ImageIO.read(in);
//
//        ImageHelper img=new ImageHelper();
//        img.saveSubImage(srcImage, rect, saveFile);*/
//
//            /**
//             * compress 图片缩放类的使用(缩略图)
//             * srcImage 为InputStream对象
//             * Rectangle    为需要截图的长方形坐标
//             * proportion 为压缩比例
//             * **/
//            InputStream in = null;
//            //缩放后需要保存的路径
//            File saveFile = new File("d:\\ABC.jpg");
//            try {
//                //原图片的路径
//                in = new FileInputStream(new File("d:\\download.jpg"));
//                if(compress(in, saveFile, 5)){
//                    System.out.println("图片压缩5倍！");
//                }
//            } catch (Exception e) {
//                e.printStackTrace();
//            } finally {
//                in.close();
//            }
//        }
//        /**
//         * 更改图片大小。按宽高更改。不保证图片原始比例(不推荐使用)
//         *
//         * @author 小帅丶
//         * @Date  2019/10/12
//         * @param originalImage
//         * @param type   处理类型
//         *              BufferedImage originalImage = ImageIO.read(new File(image));//change path to where file is located
//         *             int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
//         * @param IMG_WIDTH  宽度
//         * @param IMG_HEIGHT 高度
//         * @return java.awt.image.BufferedImage
//         **/
//        public static BufferedImage resizeImage(BufferedImage originalImage, int type, int IMG_WIDTH, int IMG_HEIGHT) {
//            BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, type);
//            Graphics2D g = resizedImage.createGraphics();
//            g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
//            g.dispose();
//            return resizedImage;
//        }
//    }




}
